home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / compiler / symbols.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  17KB  |  499 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Module symbol-table generator'''
  5. from compiler import ast
  6. from compiler.consts import SC_LOCAL, SC_GLOBAL, SC_FREE, SC_CELL, SC_UNKNOWN
  7. from compiler.misc import mangle
  8. import types
  9. import sys
  10. MANGLE_LEN = 256
  11.  
  12. class Scope:
  13.     
  14.     def __init__(self, name, module, klass = None):
  15.         self.name = name
  16.         self.module = module
  17.         self.defs = { }
  18.         self.uses = { }
  19.         self.globals = { }
  20.         self.params = { }
  21.         self.frees = { }
  22.         self.cells = { }
  23.         self.children = []
  24.         self.nested = None
  25.         self.generator = None
  26.         self.klass = None
  27.         if klass is not None:
  28.             for i in range(len(klass)):
  29.                 if klass[i] != '_':
  30.                     self.klass = klass[i:]
  31.                     break
  32.                     continue
  33.             
  34.         
  35.  
  36.     
  37.     def __repr__(self):
  38.         return '<%s: %s>' % (self.__class__.__name__, self.name)
  39.  
  40.     
  41.     def mangle(self, name):
  42.         if self.klass is None:
  43.             return name
  44.         
  45.         return mangle(name, self.klass)
  46.  
  47.     
  48.     def add_def(self, name):
  49.         self.defs[self.mangle(name)] = 1
  50.  
  51.     
  52.     def add_use(self, name):
  53.         self.uses[self.mangle(name)] = 1
  54.  
  55.     
  56.     def add_global(self, name):
  57.         name = self.mangle(name)
  58.         if self.uses.has_key(name) or self.defs.has_key(name):
  59.             pass
  60.         
  61.         if self.params.has_key(name):
  62.             raise SyntaxError, '%s in %s is global and parameter' % (name, self.name)
  63.         
  64.         self.globals[name] = 1
  65.         self.module.add_def(name)
  66.  
  67.     
  68.     def add_param(self, name):
  69.         name = self.mangle(name)
  70.         self.defs[name] = 1
  71.         self.params[name] = 1
  72.  
  73.     
  74.     def get_names(self):
  75.         d = { }
  76.         d.update(self.defs)
  77.         d.update(self.uses)
  78.         d.update(self.globals)
  79.         return d.keys()
  80.  
  81.     
  82.     def add_child(self, child):
  83.         self.children.append(child)
  84.  
  85.     
  86.     def get_children(self):
  87.         return self.children
  88.  
  89.     
  90.     def DEBUG(self):
  91.         print >>sys.stderr, self.name,
  92.         if not self.nested or 'nested':
  93.             pass
  94.         print >>sys.stderr, ''
  95.         print >>sys.stderr, '\tglobals: ', self.globals
  96.         print >>sys.stderr, '\tcells: ', self.cells
  97.         print >>sys.stderr, '\tdefs: ', self.defs
  98.         print >>sys.stderr, '\tuses: ', self.uses
  99.         print >>sys.stderr, '\tfrees:', self.frees
  100.  
  101.     
  102.     def check_name(self, name):
  103.         '''Return scope of name.
  104.  
  105.         The scope of a name could be LOCAL, GLOBAL, FREE, or CELL.
  106.         '''
  107.         if self.globals.has_key(name):
  108.             return SC_GLOBAL
  109.         
  110.         if self.cells.has_key(name):
  111.             return SC_CELL
  112.         
  113.         if self.defs.has_key(name):
  114.             return SC_LOCAL
  115.         
  116.         if self.nested:
  117.             if self.frees.has_key(name) or self.uses.has_key(name):
  118.                 return SC_FREE
  119.             
  120.         if self.nested:
  121.             return SC_UNKNOWN
  122.         else:
  123.             return SC_GLOBAL
  124.  
  125.     
  126.     def get_free_vars(self):
  127.         if not self.nested:
  128.             return ()
  129.         
  130.         free = { }
  131.         free.update(self.frees)
  132.         for name in self.uses.keys():
  133.             if not self.defs.has_key(name) or self.globals.has_key(name):
  134.                 free[name] = 1
  135.                 continue
  136.         
  137.         return free.keys()
  138.  
  139.     
  140.     def handle_children(self):
  141.         for child in self.children:
  142.             frees = child.get_free_vars()
  143.             globals = self.add_frees(frees)
  144.             for name in globals:
  145.                 child.force_global(name)
  146.             
  147.         
  148.  
  149.     
  150.     def force_global(self, name):
  151.         '''Force name to be global in scope.
  152.  
  153.         Some child of the current node had a free reference to name.
  154.         When the child was processed, it was labelled a free
  155.         variable.  Now that all its enclosing scope have been
  156.         processed, the name is known to be a global or builtin.  So
  157.         walk back down the child chain and set the name to be global
  158.         rather than free.
  159.  
  160.         Be careful to stop if a child does not think the name is
  161.         free.
  162.         '''
  163.         self.globals[name] = 1
  164.         if self.frees.has_key(name):
  165.             del self.frees[name]
  166.         
  167.         for child in self.children:
  168.             if child.check_name(name) == SC_FREE:
  169.                 child.force_global(name)
  170.                 continue
  171.         
  172.  
  173.     
  174.     def add_frees(self, names):
  175.         '''Process list of free vars from nested scope.
  176.  
  177.         Returns a list of names that are either 1) declared global in the
  178.         parent or 2) undefined in a top-level parent.  In either case,
  179.         the nested scope should treat them as globals.
  180.         '''
  181.         child_globals = []
  182.         for name in names:
  183.             sc = self.check_name(name)
  184.             if self.nested:
  185.                 if sc == SC_UNKNOWN and sc == SC_FREE or isinstance(self, ClassScope):
  186.                     self.frees[name] = 1
  187.                 elif sc == SC_GLOBAL:
  188.                     child_globals.append(name)
  189.                 elif isinstance(self, FunctionScope) and sc == SC_LOCAL:
  190.                     self.cells[name] = 1
  191.                 elif sc != SC_CELL:
  192.                     child_globals.append(name)
  193.                 
  194.             sc == SC_LOCAL
  195.             if sc == SC_LOCAL:
  196.                 self.cells[name] = 1
  197.                 continue
  198.             if sc != SC_CELL:
  199.                 child_globals.append(name)
  200.                 continue
  201.         
  202.         return child_globals
  203.  
  204.     
  205.     def get_cell_vars(self):
  206.         return self.cells.keys()
  207.  
  208.  
  209.  
  210. class ModuleScope(Scope):
  211.     __super_init = Scope.__init__
  212.     
  213.     def __init__(self):
  214.         self._ModuleScope__super_init('global', self)
  215.  
  216.  
  217.  
  218. class FunctionScope(Scope):
  219.     pass
  220.  
  221.  
  222. class GenExprScope(Scope):
  223.     __super_init = Scope.__init__
  224.     __counter = 1
  225.     
  226.     def __init__(self, module, klass = None):
  227.         i = self._GenExprScope__counter
  228.         self._GenExprScope__counter += 1
  229.         self._GenExprScope__super_init('generator expression<%d>' % i, module, klass)
  230.         self.add_param('[outmost-iterable]')
  231.  
  232.     
  233.     def get_names(self):
  234.         keys = Scope.get_names()
  235.         return keys
  236.  
  237.  
  238.  
  239. class LambdaScope(FunctionScope):
  240.     __super_init = Scope.__init__
  241.     __counter = 1
  242.     
  243.     def __init__(self, module, klass = None):
  244.         i = self._LambdaScope__counter
  245.         self._LambdaScope__counter += 1
  246.         self._LambdaScope__super_init('lambda.%d' % i, module, klass)
  247.  
  248.  
  249.  
  250. class ClassScope(Scope):
  251.     __super_init = Scope.__init__
  252.     
  253.     def __init__(self, name, module):
  254.         self._ClassScope__super_init(name, module, name)
  255.  
  256.  
  257.  
  258. class SymbolVisitor:
  259.     
  260.     def __init__(self):
  261.         self.scopes = { }
  262.         self.klass = None
  263.  
  264.     
  265.     def visitModule(self, node):
  266.         scope = self.module = self.scopes[node] = ModuleScope()
  267.         self.visit(node.node, scope)
  268.  
  269.     visitExpression = visitModule
  270.     
  271.     def visitFunction(self, node, parent):
  272.         if node.decorators:
  273.             self.visit(node.decorators, parent)
  274.         
  275.         parent.add_def(node.name)
  276.         for n in node.defaults:
  277.             self.visit(n, parent)
  278.         
  279.         scope = FunctionScope(node.name, self.module, self.klass)
  280.         if parent.nested or isinstance(parent, FunctionScope):
  281.             scope.nested = 1
  282.         
  283.         self.scopes[node] = scope
  284.         self._do_args(scope, node.argnames)
  285.         self.visit(node.code, scope)
  286.         self.handle_free_vars(scope, parent)
  287.  
  288.     
  289.     def visitGenExpr(self, node, parent):
  290.         scope = GenExprScope(self.module, self.klass)
  291.         if parent.nested and isinstance(parent, FunctionScope) or isinstance(parent, GenExprScope):
  292.             scope.nested = 1
  293.         
  294.         self.scopes[node] = scope
  295.         self.visit(node.code, scope)
  296.         self.handle_free_vars(scope, parent)
  297.  
  298.     
  299.     def visitGenExprInner(self, node, scope):
  300.         for genfor in node.quals:
  301.             self.visit(genfor, scope)
  302.         
  303.         self.visit(node.expr, scope)
  304.  
  305.     
  306.     def visitGenExprFor(self, node, scope):
  307.         self.visit(node.assign, scope, 1)
  308.         self.visit(node.iter, scope)
  309.         for if_ in node.ifs:
  310.             self.visit(if_, scope)
  311.         
  312.  
  313.     
  314.     def visitGenExprIf(self, node, scope):
  315.         self.visit(node.test, scope)
  316.  
  317.     
  318.     def visitLambda(self, node, parent, assign = 0):
  319.         if not not assign:
  320.             raise AssertionError
  321.         for n in node.defaults:
  322.             self.visit(n, parent)
  323.         
  324.         scope = LambdaScope(self.module, self.klass)
  325.         if parent.nested or isinstance(parent, FunctionScope):
  326.             scope.nested = 1
  327.         
  328.         self.scopes[node] = scope
  329.         self._do_args(scope, node.argnames)
  330.         self.visit(node.code, scope)
  331.         self.handle_free_vars(scope, parent)
  332.  
  333.     
  334.     def _do_args(self, scope, args):
  335.         for name in args:
  336.             if type(name) == types.TupleType:
  337.                 self._do_args(scope, name)
  338.                 continue
  339.             scope.add_param(name)
  340.         
  341.  
  342.     
  343.     def handle_free_vars(self, scope, parent):
  344.         parent.add_child(scope)
  345.         scope.handle_children()
  346.  
  347.     
  348.     def visitClass(self, node, parent):
  349.         parent.add_def(node.name)
  350.         for n in node.bases:
  351.             self.visit(n, parent)
  352.         
  353.         scope = ClassScope(node.name, self.module)
  354.         if parent.nested or isinstance(parent, FunctionScope):
  355.             scope.nested = 1
  356.         
  357.         if node.doc is not None:
  358.             scope.add_def('__doc__')
  359.         
  360.         scope.add_def('__module__')
  361.         self.scopes[node] = scope
  362.         prev = self.klass
  363.         self.klass = node.name
  364.         self.visit(node.code, scope)
  365.         self.klass = prev
  366.         self.handle_free_vars(scope, parent)
  367.  
  368.     
  369.     def visitName(self, node, scope, assign = 0):
  370.         if assign:
  371.             scope.add_def(node.name)
  372.         else:
  373.             scope.add_use(node.name)
  374.  
  375.     
  376.     def visitFor(self, node, scope):
  377.         self.visit(node.assign, scope, 1)
  378.         self.visit(node.list, scope)
  379.         self.visit(node.body, scope)
  380.         if node.else_:
  381.             self.visit(node.else_, scope)
  382.         
  383.  
  384.     
  385.     def visitFrom(self, node, scope):
  386.         for name, asname in node.names:
  387.             if name == '*':
  388.                 continue
  389.             
  390.             if not asname:
  391.                 pass
  392.             scope.add_def(name)
  393.         
  394.  
  395.     
  396.     def visitImport(self, node, scope):
  397.         for name, asname in node.names:
  398.             i = name.find('.')
  399.             if i > -1:
  400.                 name = name[:i]
  401.             
  402.             if not asname:
  403.                 pass
  404.             scope.add_def(name)
  405.         
  406.  
  407.     
  408.     def visitGlobal(self, node, scope):
  409.         for name in node.names:
  410.             scope.add_global(name)
  411.         
  412.  
  413.     
  414.     def visitAssign(self, node, scope):
  415.         """Propagate assignment flag down to child nodes.
  416.  
  417.         The Assign node doesn't itself contains the variables being
  418.         assigned to.  Instead, the children in node.nodes are visited
  419.         with the assign flag set to true.  When the names occur in
  420.         those nodes, they are marked as defs.
  421.  
  422.         Some names that occur in an assignment target are not bound by
  423.         the assignment, e.g. a name occurring inside a slice.  The
  424.         visitor handles these nodes specially; they do not propagate
  425.         the assign flag to their children.
  426.         """
  427.         for n in node.nodes:
  428.             self.visit(n, scope, 1)
  429.         
  430.         self.visit(node.expr, scope)
  431.  
  432.     
  433.     def visitAssName(self, node, scope, assign = 1):
  434.         scope.add_def(node.name)
  435.  
  436.     
  437.     def visitAssAttr(self, node, scope, assign = 0):
  438.         self.visit(node.expr, scope, 0)
  439.  
  440.     
  441.     def visitSubscript(self, node, scope, assign = 0):
  442.         self.visit(node.expr, scope, 0)
  443.         for n in node.subs:
  444.             self.visit(n, scope, 0)
  445.         
  446.  
  447.     
  448.     def visitSlice(self, node, scope, assign = 0):
  449.         self.visit(node.expr, scope, 0)
  450.         if node.lower:
  451.             self.visit(node.lower, scope, 0)
  452.         
  453.         if node.upper:
  454.             self.visit(node.upper, scope, 0)
  455.         
  456.  
  457.     
  458.     def visitAugAssign(self, node, scope):
  459.         self.visit(node.node, scope)
  460.         if isinstance(node.node, ast.Name):
  461.             self.visit(node.node, scope, 1)
  462.         
  463.         self.visit(node.expr, scope)
  464.  
  465.     _const_types = (types.StringType, types.IntType, types.FloatType)
  466.     
  467.     def visitIf(self, node, scope):
  468.         for test, body in node.tests:
  469.             if isinstance(test, ast.Const):
  470.                 if type(test.value) in self._const_types:
  471.                     if not test.value:
  472.                         continue
  473.                     
  474.                 
  475.             
  476.             self.visit(test, scope)
  477.             self.visit(body, scope)
  478.         
  479.         if node.else_:
  480.             self.visit(node.else_, scope)
  481.         
  482.  
  483.     
  484.     def visitYield(self, node, scope):
  485.         scope.generator = 1
  486.         self.visit(node.value, scope)
  487.  
  488.  
  489.  
  490. def sort(l):
  491.     l = l[:]
  492.     l.sort()
  493.     return l
  494.  
  495.  
  496. def list_eq(l1, l2):
  497.     return sort(l1) == sort(l2)
  498.  
  499.